/**
 * 从文件夹获取文件列表
 * @returns {Promise<Array>} 返回处理后的文件列表
 */
export const getFilesFromDirectory = async () => {
  try {
    const res = await window.electronAPI.getFilesFromDirectory();
    if (res.success) {
      const files = res.files || [];
      
      // 处理文件列表，添加格式化的更新时间和文件类型
      const processedFiles = files.map(file => {
        // 格式化更新时间
        const updateTime = new Date(file.mtime).toLocaleString('zh-CN', {
          year: 'numeric',
          month: '2-digit',
          day: '2-digit',
          hour: '2-digit',
          minute: '2-digit',
          second: '2-digit'
        });
        
        // 判断文件类型
        let fileType = '未知文件';
        if (file.fileName.includes('tasklist')) {
          fileType = '任务列表';
        } else {
          fileType = '配置文件';
        }
        
        return {
          ...file,
          updateTime,
          fileType,
          // 保留原始的mtime用于排序
          rawMtime: new Date(file.mtime).getTime()
        };
      });
      
      return processedFiles;
    } else {
      console.error('获取文件列表失败:', res.message);
      throw new Error('获取文件列表失败');
    }
  } catch (e) {
    console.error('获取文件列表异常:', e);
    throw e;
  }
};

/**
 * 解析任务列表文件，提取任务名称和任务ID
 * @param {Array} files - 文件列表
 * @returns {Promise<Array>} 解析后的任务列表
 */
export const parseTaskListFromFiles = async (files) => {
  try {
    // 过滤出任务列表文件，只获取文件名以task-开头的文件
    const taskListFiles = files.filter(file => 
      file.fileName.startsWith('task-') && file.fileName.endsWith('.xml') 
    )
    
    console.log(`找到${taskListFiles.length}个符合条件的任务列表文件（文件数量）`);
    
    if (taskListFiles.length === 0) {
      console.log('未找到符合条件的任务列表文件，请确保文件以"task-"开头且扩展名为.xml');
      return [];
    }
    
    const taskList = [];    
    // 读取并解析所有符合条件的任务列表文件
    // 使用for...of配合await确保按顺序处理文件，每个异步操作完成后再处理下一个
    for (const taskFile of taskListFiles) {      
      try {
        // 确保每次处理新文件前清除可能的缓存影响
        let result = null;        
        // await关键字会暂停代码执行，直到Promise解决（成功或失败）
        // 这确保了异步函数执行完成后，才会执行下面的代码
        result = await window.electronAPI.readFileAsArrayBuffer(taskFile.filePath); 
        // 检查读取结果是否成功
        if (!result.success || !result.data) {
          console.error(`读取任务列表文件失败(${taskFile.fileName}):`, result.error || '未知错误');
          continue;
        }
        let arrayBuffer = null;
        let fileContent = '';
        // 确保data是ArrayBuffer类型
        arrayBuffer = result.data;
        if (!(arrayBuffer instanceof ArrayBuffer)) {
          console.error(`读取的文件数据不是ArrayBuffer类型(${taskFile.fileName}):`, typeof arrayBuffer);
          continue;
        }
        
        // 将ArrayBuffer转换为文本
        fileContent = new TextDecoder().decode(arrayBuffer);
        // 检查ArrayBuffer是否为空
        if (arrayBuffer.byteLength === 0) {
          console.error(`文件内容为空，ArrayBuffer长度为0(${taskFile.fileName})`);
          continue;
        }
        
        // 检查转换后的文本是否为空或仅包含空白字符
        if (!fileContent || /^\s*$/.test(fileContent)) {
          console.error(`文件内容为空或仅包含空白字符(${taskFile.fileName})`);
          continue;
        }
        
        // 每个文件只解析一个任务
        let taskId = '';
        let taskName = '';
        const paramConfigs = [];
        
        // 尝试从文件名提取任务ID，用于匹配
        const fileNameTaskIdMatch = taskFile.fileName.match(/task-(\d+)\.xml/i);
        const expectedTaskId = fileNameTaskIdMatch ? fileNameTaskIdMatch[1] : null;
        
        // 匹配所有的<PAR_SETUP>结构
        const parSetupRegex = /<PAR_SETUP[\s\S]*?<\/PAR_SETUP>/gi;
        const parSetupMatches = fileContent.match(parSetupRegex) || [];
        
        // 遍历每个<PAR_SETUP>结构
        let foundMatchingSetup = false;
        for (const setupBlock of parSetupMatches) {
            // 从当前结构中提取TaskID
            const blockTaskIdMatch = setupBlock.match(/<TaskID>(\d+)<\/TaskID>/i);
            const blockTaskId = blockTaskIdMatch && blockTaskIdMatch[1] ? blockTaskIdMatch[1].trim() : '';
            
            if (blockTaskId) {
                // 检查文件名是否包含当前结构的TaskID
                if (expectedTaskId && taskFile.fileName.includes(blockTaskId)) {
                    // 提取该结构中的TaskName
                    const blockTaskNameMatch = setupBlock.match(/<TaskName>(.*?)<\/TaskName>/i);
                    taskName = blockTaskNameMatch && blockTaskNameMatch[1] ? blockTaskNameMatch[1].trim() : '';
                    
                    // 设置任务ID
                    taskId = blockTaskId;
                    
                    // 提取该结构中的所有Param标签
                    const blockParamRegex = /<Param\s+[^>]*>/g;
                    const blockParamTags = setupBlock.match(blockParamRegex) || [];
                    
                    // 遍历每个Param标签进行解析
                    blockParamTags.forEach(tag => {
                        // 使用正则表达式解析Param标签中的各个属性，不依赖属性顺序
                        // 使用非贪婪匹配，允许属性值为空
                        const paraIdMatch = /ParaID="([^"]*)"/.exec(tag);
                        const cnNameMatch = /CNName="([^"]*)"/.exec(tag);
                        const paraFlagMatch = /ParaFlag="([^"]*)"/.exec(tag);
                        const paraNameMatch = /ParaName="([^"]*)"/.exec(tag);
                        const dataTypeMatch = /DataType="([^"]*)"/.exec(tag);
                        const offsetMatch = /Offset="([^"]*)"/.exec(tag);
                        const offsetValue = offsetMatch ? parseInt(offsetMatch[1], 10) : null;
                        
                        if (paraIdMatch && paraIdMatch[1]) {
                            const newParaId = paraIdMatch[1] || '';
                            // 检查paramConfigs中是否已存在相同ParaID的配置
                            const isExists = paramConfigs.some(config => config.ParaID === newParaId);
                            
                            if (!isExists) {
                                paramConfigs.push({
                                    ParaID: newParaId,
                                    CNName: cnNameMatch ? cnNameMatch[1] : '',
                                    ParaFlag: paraFlagMatch ? paraFlagMatch[1] : '',
                                    ParaName: paraNameMatch ? paraNameMatch[1] : '',
                                    DataType: dataTypeMatch ? dataTypeMatch[1] : '',
                                    Offset: offsetValue
                                });
                            }
                        }
                    });
                    
                    // 标记已找到匹配的结构，避免重复处理
                    foundMatchingSetup = true;
                    break; // 找到匹配的结构后退出循环
                }
            }
        }
        
        // 如果没有找到匹配的结构，但文件内容中存在TaskID和TaskName，仍然尝试处理
        if (!foundMatchingSetup) {
            console.log(`[回退处理] 未找到与文件名匹配的<PAR_SETUP>结构，尝试从整个文件提取基本信息`);
            
            // 尝试从文件内容中提取TaskName和TaskID标签对
            const taskIdMatch = fileContent.match(/<TaskID>(\d+)<\/TaskID>/i);
            if (taskIdMatch && taskIdMatch[1]) {
              taskId = taskIdMatch[1].trim(); // 使用捕获组[1]获取标签内的数字
            }
        
            const taskNameMatch = fileContent.match(/<TaskName>(.*?)<\/TaskName>/i);
            if (taskNameMatch && taskNameMatch[1]) {
              taskName = taskNameMatch[1].trim(); // 使用捕获组[1]获取标签内的名称
            }
        }

        // 每个文件只添加一个任务
        taskList.push({ id: taskId, name: taskName ,paramConfigs:paramConfigs});
      } catch (fileParseError) {
        console.error(`解析任务列表文件失败(${taskFile.fileName}):`, fileParseError);
        // 继续处理下一个文件
      }
    }
    
    console.log(`成功解析所有任务列表文件，总共找到${taskList.length}个任务（任务总数）`);
    // 确保返回的任务列表格式正确，每个任务都有id和name字段
    return taskList.map(task => ({
      id: task.id,
      name: task.name || '未命名任务',
      paramConfigs: task.paramConfigs || []
    }));
  } catch (e) {
    console.error('从文件解析任务列表异常:', e);
    return [];
  }
};

/**
 * 获取格式化的任务列表
 * @returns {Promise<Array>} 格式化后的任务列表
 */
export const getFormattedTaskList = async () => {
  try {
    // 获取文件列表
    const files = await getFilesFromDirectory(); 
    console.log('获取到的遥测数据文件:',files);
    // 从文件中解析任务列表
    const taskList = await parseTaskListFromFiles(files);
    
    return taskList;
  } catch (e) {
    console.error('获取格式化任务列表失败:', e);
    return [];
  }
};